home *** CD-ROM | disk | FTP | other *** search
/ InterCD 2000 September / september_2000.iso / intercd / root / ^Linux / WindowMaker / WINGs / wpixmap.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-10-09  |  5.0 KB  |  260 lines
  1.  
  2. #include "WINGsP.h"
  3.  
  4. #include <wraster.h>
  5.  
  6.  
  7. WMPixmap*
  8. WMRetainPixmap(WMPixmap *pixmap)
  9. {
  10.     if (pixmap)
  11.     pixmap->refCount++;
  12.  
  13.     return pixmap;
  14. }
  15.  
  16.  
  17. void
  18. WMReleasePixmap(WMPixmap *pixmap)
  19. {
  20.     wassertr(pixmap!=NULL);
  21.  
  22.     pixmap->refCount--;
  23.  
  24.     if (pixmap->refCount<1) {
  25.     if (pixmap->pixmap)
  26.         XFreePixmap(pixmap->screen->display, pixmap->pixmap);
  27.     if (pixmap->mask)
  28.         XFreePixmap(pixmap->screen->display, pixmap->mask);
  29.     wfree(pixmap);
  30.     }
  31. }
  32.  
  33.  
  34. WMPixmap*
  35. WMCreatePixmap(WMScreen *scrPtr, int width, int height, int depth, Bool masked)
  36. {
  37.     WMPixmap *pixPtr;
  38.  
  39.     pixPtr = malloc(sizeof(WMPixmap));
  40.     if (!pixPtr) {
  41.     return NULL;
  42.     }
  43.     pixPtr->screen = scrPtr;
  44.     pixPtr->width = width;
  45.     pixPtr->height = height;
  46.     pixPtr->depth = depth;
  47.     pixPtr->refCount = 1;
  48.  
  49.     pixPtr->pixmap = XCreatePixmap(scrPtr->display, W_DRAWABLE(scrPtr),
  50.                    width, height, depth);
  51.     if (masked) {
  52.         pixPtr->mask = XCreatePixmap(scrPtr->display, W_DRAWABLE(scrPtr),
  53.                      width, height, 1);
  54.     } else {
  55.     pixPtr->mask = None;
  56.     }
  57.  
  58.     return pixPtr;    
  59. }
  60.  
  61.  
  62. WMPixmap*
  63. WMCreatePixmapFromXPixmaps(WMScreen *scrPtr, Pixmap pixmap, Pixmap mask,
  64.                int width, int height, int depth)
  65. {
  66.     WMPixmap *pixPtr;
  67.  
  68.     pixPtr = malloc(sizeof(WMPixmap));
  69.     if (!pixPtr) {
  70.     return NULL;
  71.     }
  72.     pixPtr->screen = scrPtr;
  73.     pixPtr->pixmap = pixmap;
  74.     pixPtr->mask = mask;
  75.     pixPtr->width = width;
  76.     pixPtr->height = height;
  77.     pixPtr->depth = depth;
  78.     pixPtr->refCount = 1;
  79.     
  80.     return pixPtr;
  81. }
  82.  
  83.  
  84.  
  85.  
  86. WMPixmap*
  87. WMCreatePixmapFromFile(WMScreen *scrPtr, char *fileName)
  88. {
  89.     WMPixmap *pixPtr;
  90.     RImage *image;
  91.     
  92.     image = RLoadImage(scrPtr->rcontext, fileName, 0);
  93.     if (!image)
  94.     return NULL;
  95.  
  96.     pixPtr = WMCreatePixmapFromRImage(scrPtr, image, 127);
  97.  
  98.     RDestroyImage(image);
  99.     
  100.     return pixPtr;
  101. }
  102.  
  103.  
  104. WMPixmap*
  105. WMCreatePixmapFromRImage(WMScreen *scrPtr, RImage *image, int threshold)
  106. {
  107.     WMPixmap *pixPtr;
  108.     Pixmap pixmap, mask;
  109.  
  110.     if (!RConvertImageMask(scrPtr->rcontext, image, &pixmap, &mask, 
  111.                threshold)) {
  112.     return NULL;
  113.     }
  114.     
  115.     pixPtr = malloc(sizeof(WMPixmap));
  116.     if (!pixPtr) {
  117.     return NULL;
  118.     }
  119.     pixPtr->screen = scrPtr;
  120.     pixPtr->pixmap = pixmap;
  121.     pixPtr->mask = mask;
  122.     pixPtr->width = image->width;
  123.     pixPtr->height = image->height;
  124.     pixPtr->depth = scrPtr->depth;
  125.     pixPtr->refCount = 1;
  126.  
  127.     return pixPtr;    
  128. }
  129.  
  130.  
  131. WMPixmap*
  132. WMCreateBlendedPixmapFromFile(WMScreen *scrPtr, char *fileName, RColor *color)
  133. {
  134.     WMPixmap *pixPtr;
  135.     RImage *image;
  136.  
  137.     
  138.     image = RLoadImage(scrPtr->rcontext, fileName, 0);
  139.     if (!image)
  140.     return NULL;
  141.     
  142.     RCombineImageWithColor(image, color);
  143.  
  144.     pixPtr = WMCreatePixmapFromRImage(scrPtr, image, 0);
  145.     
  146.     RDestroyImage(image);
  147.     
  148.     return pixPtr;
  149. }
  150.  
  151.  
  152. WMPixmap*
  153. WMCreatePixmapFromXPMData(WMScreen *scrPtr, char **data)
  154. {
  155.     WMPixmap *pixPtr;
  156.     RImage *image;
  157.  
  158.     image = RGetImageFromXPMData(scrPtr->rcontext, data);
  159.     if (!image)
  160.     return NULL;
  161.     
  162.     pixPtr = WMCreatePixmapFromRImage(scrPtr, image, 127);
  163.  
  164.     RDestroyImage(image);
  165.     
  166.     return pixPtr;
  167. }
  168.  
  169.  
  170. Pixmap
  171. WMGetPixmapXID(WMPixmap *pixmap)
  172. {
  173.     wassertrv(pixmap != NULL, None);
  174.  
  175.     return pixmap->pixmap;
  176. }
  177.  
  178.  
  179. Pixmap
  180. WMGetPixmapMaskXID(WMPixmap *pixmap)
  181. {
  182.     wassertrv(pixmap != NULL, None);
  183.  
  184.     return pixmap->mask;
  185. }
  186.  
  187.  
  188. WMSize 
  189. WMGetPixmapSize(WMPixmap *pixmap)
  190. {
  191.     WMSize size = {0,0};
  192.  
  193.     wassertrv(pixmap != NULL, size);
  194.     
  195.     size.width = pixmap->width;
  196.     size.height = pixmap->height;
  197.  
  198.     return size;
  199. }
  200.  
  201.  
  202. WMPixmap*
  203. WMGetSystemPixmap(WMScreen *scr, int image)
  204. {
  205.     switch (image) {
  206.      case WSIReturnArrow:
  207.     return WMRetainPixmap(scr->buttonArrow);
  208.     
  209.      case WSIHighlightedReturnArrow:
  210.     return WMRetainPixmap(scr->pushedButtonArrow);
  211.     
  212.      case WSIScrollerDimple:
  213.     return WMRetainPixmap(scr->scrollerDimple);
  214.     
  215.      case WSIArrowLeft:
  216.     return WMRetainPixmap(scr->leftArrow);
  217.     
  218.      case WSIHighlightedArrowLeft:
  219.     return WMRetainPixmap(scr->hiLeftArrow);
  220.     
  221.      case WSIArrowRight:
  222.     return WMRetainPixmap(scr->rightArrow);
  223.     
  224.      case WSIHighlightedArrowRight:
  225.     return WMRetainPixmap(scr->hiRightArrow);
  226.     
  227.      case WSIArrowUp:
  228.     return WMRetainPixmap(scr->upArrow);
  229.     
  230.      case WSIHighlightedArrowUp:
  231.     return WMRetainPixmap(scr->hiUpArrow);
  232.     
  233.      case WSIArrowDown:
  234.     return WMRetainPixmap(scr->downArrow);
  235.     
  236.      case WSIHighlightedArrowDown:
  237.     return WMRetainPixmap(scr->hiDownArrow);
  238.  
  239.      case WSICheckMark:
  240.     return WMRetainPixmap(scr->checkMark);
  241.  
  242.      default:
  243.     return NULL;
  244.     }
  245. }
  246.  
  247.  
  248.  
  249. void
  250. WMDrawPixmap(WMPixmap *pixmap, Drawable d, int x, int y)
  251. {
  252.     WMScreen *scr = pixmap->screen;
  253.  
  254.     XSetClipMask(scr->display, scr->clipGC, pixmap->mask);
  255.     XSetClipOrigin(scr->display, scr->clipGC, x, y);
  256.  
  257.     XCopyArea(scr->display, pixmap->pixmap, d, scr->clipGC, 0, 0, 
  258.           pixmap->width, pixmap->height, x, y);
  259. }
  260.